package com.ssy.invoicing.common.util;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.time.DateUtils;

/**
 * 时间操作类
 * @author wb_suoyao.shen
 */
public class DateUtil extends DateUtils {

    /** 时间标志位 */
    public static final int       DAY_FLAG_NEXTYEAR         = -1;
    public static final int       DAY_FLAG_TOMORROW         = 0;
    public static final int       DAY_FLAG_TODAY            = 1;
    /** 昨天 */
    public static final int       DAY_FLAG_YESTERDAY        = 2;
    public static final int       DAY_FLAG_CURRENT_WEEK     = 3;
    public static final int       DAY_FLAG_LAST_WEEK        = 4;
    public static final int       DAY_FLAG_THIS_YEAR        = 5;
    public static final int       DAY_FLAG_OTHER            = 6;

    public static final String    DATE_FORMAT_TABLE_NAME    = "yyyyMMdd";
    public static final String    DATE_FORMAT_XAXIS         = "yy/MM/dd";
    public static final String    DATE_FORMAT               = "yyyy-MM-dd";
    public static final String    DAY_FORMAT                = "MM月dd日";
    public static final String    DAY_FORMAT_EN             = "MM-dd";
    public static final String    DAY_FORMAT_YESTERDAY      = "昨天HH:mm";
    public static final String    DAY_FORMAT_YESTERDAY_EN   = "HH:mm";
    public static final String    TIME_FORMAT               = "HH:mm";

    public static final String    DATE_FORMAT_B             = "yyyy-MM-dd HH:mm:ss";
    public static final String    DATE_FORMAT_C             = "yyyy年MM月dd日 HH:mm";
    public static final String    DATE_FORMAT_C_EN          = "yyyy-MM-dd HH:mm";
    public static final String    DATE_FORMAT_D             = "EEE, d MMM yyyy HH:mm:ss Z";
    public static final String    DATE_FORMAT_ZONE          = "yyyy/MM/dd HH:mm:ss Z";
    public static final String    DATE_FORMAT_VIEW_CN       = "yyyy年MM月dd日(EEE) HH:mm";
    public static final String    DATE_FORMAT_VIEW_EN       = DATE_FORMAT_B;
    // 2010年2月21日 11:04
    public static final String    DATE_FORMAT_REPLY_CN      = "yyyy年MM月dd日 HH:mm";
    public static final String    DATE_FORMAT_REPLY_EN      = "yyyy-MM-dd HH:mm";

    private static final String[] DAY_OF_WEEK_NAME          = new String[] { "周日", "周一", "周二",
            "周三", "周四", "周五", "周六"                         };
    private static final String[] DAY_OF_WEEK_NAME_EN       = new String[] { "Sunday", "Monday",
            "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };

    private static final String[] DAY_OF_WEEK_SHORT_NAME    = new String[] { "日", "一", "二", "三",
            "四", "五", "六"                                  };
    private static final String[] DAY_OF_WEEK_SHORT_NAME_EN = new String[] { "Sun", "Mon", "Tue",
            "Wed", "Thu", "Fri", "Sat"                     };

    public static final String    DATE_FORMAT_SEND_MAIL     = "yyyy-MM-dd HH:mm:ss Z";
    public static final String    WS_DATE_FORMAT            = "yyyy/MM/dd HH:mm:ss Z";

    /**
     * 把输入的时间格式化成为字符串 备注： 相关邮件显示业务逻辑如下： <br/>
     * 1. 如果当天是一周的第3～7天，则显示今天，昨天，本周，上周，更早。 对应日期如没有邮件，该项不显示。<br/>
     * 2. 如果当天是一周的第1天，显示今天、上周、更早，没有昨天和本周 <br/>
     * 3. 如果当天是一周的第2天，则显示今天，昨天，上周，没有本周<br/>
     * 格式化输入的时间，并返回 今天、昨天、本周、上周、更早 今天：显示时刻 如：19：24 昨天：显示昨天+时间 如：昨天19：24
     * 本周：显示日期+(周几) 如：11月17日（周二） 上周：显示日期 如：11月12日 更早： 今年显示日期 如：10月12日； 往年显示年月日期
     * 如：2008-10-12
     * 
     * @param date 时间
     * @param locale 地区
     * @return String 时间字符串
     */
    public static String formateMailDate(Date date, Locale locale) {
        return formateMailDate(date, new Date(), locale);
    }

    /**
     * 把输入的时间格式化成为字符串 备注： 相关邮件显示业务逻辑如下： <br/>
     * 1. 如果当天是一周的第3～7天，则显示今天，昨天，本周，上周，更早。 对应日期如没有邮件，该项不显示。<br/>
     * 2. 如果当天是一周的第1天，显示今天、上周、更早，没有昨天和本周 <br/>
     * 3. 如果当天是一周的第2天，则显示今天，昨天，上周，没有本周<br/>
     * 格式化输入的时间，并返回 今天、昨天、本周、上周、更早 今天：显示时刻 如：19：24 昨天：显示昨天+时间 如：昨天19：24
     * 本周：显示日期+(周几) 如：11月17日（周二） 上周：显示日期 如：11月12日 更早： 今年显示日期 如：10月12日； 往年显示年月日期
     * 如：2008-10-12
     * 
     * @param date 时间
     * @param currentDate 当天时间
     * @param locale 地区
     * @return String 时间字符串
     */
    public static String formateMailDate(Date date, Date currentDate, Locale locale) {
        if (date == null || currentDate == null) {
            return "";
        }
        // 时间标记
        int dayFlag = getDayFlag(date, currentDate);
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        String strDate = "";
        String format = "";
        switch (dayFlag) {
            //如果是明年
            case DateUtil.DAY_FLAG_NEXTYEAR:
                strDate = formateDate(date, DATE_FORMAT);
                break;
            //如果是明天以前本年之内
            case DateUtil.DAY_FLAG_TOMORROW:
                if (locale == null || "zh".equals(locale.getLanguage())
                        || "zh_cn".equals(locale.getLanguage())) {
                    format = DAY_FORMAT;
                } else {
                    format = DAY_FORMAT_EN;
                }
                strDate = formateDate(date, format);
                break;
            // 输入时间是当天
            case DateUtil.DAY_FLAG_TODAY:
                strDate = formateDate(date, TIME_FORMAT);
                break;
            // 输入时间是昨天
            case DateUtil.DAY_FLAG_YESTERDAY:
                if (locale == null || "zh".equals(locale.getLanguage())
                        || "zh_cn".equals(locale.getLanguage())) {
                    format = DAY_FORMAT_YESTERDAY;
                    strDate = formateDate(date, format);
                } else {
                    format = DAY_FORMAT_YESTERDAY_EN;
                    strDate = "Yesterday" + formateDate(date, format);
                }
                break;
            // 输入时间是本周
            case DateUtil.DAY_FLAG_CURRENT_WEEK:
                // 本周：显示日期+(周几)       如：11月17日（周二）
                StringBuffer sb = new StringBuffer();

                if (locale == null || "zh".equals(locale.getLanguage())
                        || "zh_cn".equals(locale.getLanguage())) {
                    sb.append(formateDate(date, DAY_FORMAT)).append("（")
                            .append(DAY_OF_WEEK_NAME[cal.get(Calendar.DAY_OF_WEEK) - 1])
                            .append("）");
                } else {
                    sb.append(formateDate(date, DAY_FORMAT_EN)).append("(")
                            .append(DAY_OF_WEEK_NAME_EN[cal.get(Calendar.DAY_OF_WEEK) - 1])
                            .append(")");
                }

                strDate = sb.toString();
                break;
            case DateUtil.DAY_FLAG_OTHER:
                strDate = formateDate(date, DATE_FORMAT);
                break;
            // 如果是上周、本年
            default:
                if (locale == null || "zh".equals(locale.getLanguage())
                        || "zh_cn".equals(locale.getLanguage())) {
                    strDate = formateDate(date, DAY_FORMAT);
                } else {
                    strDate = formateDate(date, DAY_FORMAT_EN);
                }
        }

        return strDate;
    }

    /**
     * 根据输入时间，返回对应的标志位。规则如下所示： 相关邮件显示业务逻辑如下： 1. 如果当天是一周的第3～7天，则显示今天，昨天，本周，上周，更早。
     * 对应日期如没有邮件，该项不显示。<br/>
     * 2. 如果当天是一周的第1天，显示今天、上周、更早，没有昨天和本周 <br/>
     * 3. 如果当天是一周的第2天，则显示今天，昨天，上周，没有本周<br/>
     * 返回数值如下所示：<br/>
     * 如果是当天返回 DateUtil.DAY_FLAG_TODAY（包含今天和将来的）<br/>
     * 如果是昨天返回 DateUtil.DAY_FLAG_YESTADAY<br/>
     * 如果是本周返回 DateUtil.DAY_FLAG_CURRENT_WEEK<br/>
     * 如果是上周返回 DateUtil.DAY_FLAG_LAST_WEEK<br/>
     * 如果是本年返回 DateUtil.DAY_FLAG_THIS_YEAR<br/>
     * 如果是其它返回 DateUtil.DAY_FLAG_OTHER <br/>
     * 
     * @param date 时间
     * @return int 时间标记
     * @throws exception if date is null
     */
    public static int getDayFlag(Date date) throws IllegalArgumentException {
        return getDayFlag(date, new Date());
    }

    /**
     * 与<code>getDayFlag(int date)</code>相同，当前时间为currentDate。 当传入的date或current
     * 
     * @see #getDayFlag(Date)
     * @param date
     * @param currentDate
     * @return
     */
    public static int getDayFlag(Date date, Date currentDate) {
        if (date == null || currentDate == null) {
            // 业务逻辑上认为null date属于OTHER类型
            return DAY_FLAG_OTHER;
        }

        // get today's start time calendar
        Calendar checkPoint = Calendar.getInstance();
        checkPoint.setTime(currentDate);
        checkPoint.set(Calendar.HOUR_OF_DAY, 0);
        checkPoint.set(Calendar.MINUTE, 0);
        checkPoint.set(Calendar.SECOND, 0);
        checkPoint.set(Calendar.MILLISECOND, 0);

        // get date's calendar
        Calendar dateToCheck = Calendar.getInstance();
        dateToCheck.setTime(date);

        Calendar nextyear = Calendar.getInstance();
        nextyear.setTime(currentDate);
        nextyear.add(Calendar.YEAR, 1);
        nextyear.set(Calendar.MONTH, 0);
        nextyear.set(Calendar.DATE, 1);
        nextyear.set(Calendar.HOUR_OF_DAY, 0);
        nextyear.set(Calendar.MINUTE, 0);
        nextyear.set(Calendar.SECOND, 0);
        nextyear.set(Calendar.MILLISECOND, 0);

        if (dateToCheck.compareTo(nextyear) >= 0) {
            return DateUtil.DAY_FLAG_NEXTYEAR;
        }

        Calendar tomorrow = Calendar.getInstance();
        tomorrow.setTime(currentDate);
        tomorrow.add(Calendar.DAY_OF_YEAR, 1);
        tomorrow.set(Calendar.HOUR_OF_DAY, 0);
        tomorrow.set(Calendar.MINUTE, 0);
        tomorrow.set(Calendar.SECOND, 0);
        tomorrow.set(Calendar.MILLISECOND, 0);

        if (dateToCheck.compareTo(nextyear) < 0 && dateToCheck.compareTo(tomorrow) >= 0) {
            return DateUtil.DAY_FLAG_TOMORROW;
        }

        // 如果是当天凌晨0点之后
        if (dateToCheck.compareTo(checkPoint) >= 0) {
            return DateUtil.DAY_FLAG_TODAY;
        }

        int dayOfWeek = checkPoint.get(Calendar.DAY_OF_WEEK);
        // 如果当前是周一或者以后，则看是否是昨天
        if (dayOfWeek >= Calendar.MONDAY) {
            checkPoint.add(Calendar.DATE, -1);
            // 如果输入时间大于昨天凌晨0点
            if (dateToCheck.compareTo(checkPoint) >= 0) {
                return DateUtil.DAY_FLAG_YESTERDAY;
            }
            // 如果当前是周二以后,要判断是否是当周
            if (dayOfWeek >= Calendar.TUESDAY) {
                // 设置时间为本周日凌晨0点
                checkPoint.add(Calendar.DAY_OF_MONTH, ((dayOfWeek * -1) + 2));
                // 如果当前时间大于本周日凌晨0点
                if (dateToCheck.compareTo(checkPoint) >= 0) {
                    // 本周：显示日期+(周几)       如：11月17日（周二）
                    StringBuffer sb = new StringBuffer();
                    sb.append(formateDate(date, DAY_FORMAT)).append("（")
                            .append(DAY_OF_WEEK_NAME[dateToCheck.get(Calendar.DAY_OF_WEEK) - 1])
                            .append("）");
                    return DateUtil.DAY_FLAG_CURRENT_WEEK;
                }
            }
        }
        // 设置时间为上周日凌晨0点
        checkPoint.add(Calendar.DAY_OF_MONTH, -7);
        // 如果当前时间大于等于上周日凌晨0点
        if (dateToCheck.compareTo(checkPoint) >= 0) {
            // 显示上周
            return DateUtil.DAY_FLAG_LAST_WEEK;
        } else {
            // 显示更早
            // 取得当前1月1日凌晨0点
            checkPoint = Calendar.getInstance();
            checkPoint.setTime(currentDate);
            checkPoint.set(Calendar.DAY_OF_YEAR, 1);
            checkPoint.set(Calendar.HOUR_OF_DAY, 0);
            checkPoint.set(Calendar.MINUTE, 0);
            checkPoint.set(Calendar.SECOND, 0);
            checkPoint.set(Calendar.MILLISECOND, 0);
            if (dateToCheck.compareTo(checkPoint) >= 0) {
                // 今年显示日期      如：10月12日
                return DateUtil.DAY_FLAG_THIS_YEAR;
            } else {
                // 往年显示年月日期  如：2008-10-12
                return DateUtil.DAY_FLAG_OTHER;
            }
        }
    }

    /**
     * 根据指定的格式格式化输入时间，并返回
     * 
     * @param date 时间
     * @param format 格式
     * @return String 格式化之后的字符串
     */
    public static String formateDate(Date date, String format) {
        if (date == null) {
            return "";
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        return dateFormat.format(date);
    }
    
    public static String formateDate(String date, String format) {
        if (date == null) {
            return "";
        }
        Date date2=parseDate(date, format);
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        return dateFormat.format(date2);
    }

    /**
     * 根据指定的格式格式化输入时间，并返回
     * 
     * @param date 时间
     * @param format 格式
     * @return String 格式化之后的字符串
     */
    public static String formateDate(Long date, String format) {
        if (date == null) {
            return "";
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        return dateFormat.format(new Date(date));
    }

    /**
     * 把指定的字符串数据格式化时间数据，并返回
     * 
     * @param date 时间字符串
     * @param format 格式
     * @return Date 时间 如果输入为空返回null
     * @exception RuntimeException 如果数据格式不正确
     */
    public static Date parseDate(String date, String format) {
        if (date == null) {
            return null;
        }
        date = date.trim();
        if (date.length() == 0) {
            return null;
        }
        SimpleDateFormat dateFormat = new SimpleDateFormat(format);
        try {
            return dateFormat.parse(date);
        } catch (ParseException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 格式化时间 格式为：例如2009年12月12日 14：23（二）
     * 
     * @param date 时间
     * @param locale 本地化信息
     * @return String 如够date为空，则返回null
     */
    public static String formateDateB(Date date, Locale locale) {
        if (date == null) {
            return "";
        }
        StringBuilder sb = new StringBuilder();

        String format = "";
        if (locale == null || "zh".equals(locale.getLanguage())
                || "zh_cn".equals(locale.getLanguage())) {
            format = DATE_FORMAT_C;
        } else {
            format = DATE_FORMAT_C_EN;
        }
        sb.append(formateDate(date, format));
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);

        if (locale == null || "zh".equals(locale.getLanguage())
                || "zh_cn".equals(locale.getLanguage())) {
            sb.append("（").append(DAY_OF_WEEK_SHORT_NAME[calendar.get(Calendar.DAY_OF_WEEK) - 1])
                    .append("）");
        } else {
            sb.append("(")
                    .append(DAY_OF_WEEK_SHORT_NAME_EN[calendar.get(Calendar.DAY_OF_WEEK) - 1])
                    .append(")");
        }

        return sb.toString();
    }

    /**
     * 把字符串解析为时间类型,解析如下类型格式的时间：<br/>
     * EEE, d MMM yyyy HH:mm:ss Z<br/>
     * 时区为：Locale.US
     * 
     * @param date 时间字符串
     * @return Date 时间
     * @throws ParseException 解析失败
     */
    public static Date parse(String date) throws ParseException {
        if (date == null) {
            return null;
        }
        date = date.trim();
        if (date.length() == 0) {
            return null;
        }
        SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT_D, Locale.US);
        return format.parse(date);
    }

    /**
     * 把字符串解析为时间类型,解析如下类型格式的时间：<br/>
     * EEE, d MMM yyyy HH:mm:ss Z<br/>
     * 时区为：Locale.US
     * 
     * @param date 时间字符串
     * @return Date 时间
     * @throws ParseException 解析失败
     */
    public static String formateDataC(Date date) {
        if (date == null) {
            return null;
        }
        try {
            SimpleDateFormat format = new SimpleDateFormat(DATE_FORMAT_D, Locale.US);
            return format.format(date);
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 把时间类型解析为字符串,解析如下类型格式的时间：<br/>
     * 2008年1月1日（星期一）上午 09:30<br/>
     * 
     * @param date 时间字符串
     * @return Date 时间
     * @throws ParseException 解析失败
     */
    public static String formatMailViewDate(Date date, Locale locale) throws ParseException {
        if (date == null)
            return "";

        SimpleDateFormat format = null;
        if (locale == null || "zh".equals(locale.getLanguage())
                || "zh_cn".equals(locale.getLanguage())) {
            format = new SimpleDateFormat(DATE_FORMAT_VIEW_CN, Locale.CHINA);
        } else {
            format = new SimpleDateFormat(DATE_FORMAT_VIEW_EN, Locale.CHINA);
        }

        return format.format(date);
    }

    /**
     * 把时间类型解析为字符串,解析如下类型格式的时间：<br/>
     * 2008年1月1日（星期一）上午 09:30<br/>
     * 
     * @param date 时间字符串
     * @return Date 时间
     * @throws ParseException 解析失败
     */
    public static String formatReplyDate(Date date, Locale locale) throws ParseException {
        if (date == null)
            return "";

        SimpleDateFormat format = null;
        if (locale == null || "zh".equals(locale.getLanguage())
                || "zh_cn".equals(locale.getLanguage())) {
            format = new SimpleDateFormat(DATE_FORMAT_REPLY_CN, Locale.CHINA);
        } else {
            format = new SimpleDateFormat(DATE_FORMAT_REPLY_EN, Locale.CHINA);
        }

        return format.format(date);
    }

    /**
     * 把ws时间类型解析为Date,解析如下类型格式的时间：<br/>
     * 
     * @param date 时间字符串
     * @return Date 时间
     * @throws ParseException 解析失败
     */
    public static Date parseWsDate(String date) throws ParseException {
        return parseDate(date, WS_DATE_FORMAT);
    }

    public static final int               FULL_NAME     = 0;
    public static final int               SHORT_NAME    = 1;
    public static final int               SHORTEST_NAME = 2;

    private static Map<Integer, String[]> weekdayNames  = buildWeekdayNamesTable();
    private static Map<Integer, String[]> monthNames    = buildMonthNamesTable();

    private static Map<Integer, String[]> buildWeekdayNamesTable() {
        Map<Integer, String[]> m = new HashMap<Integer, String[]>();

        m.put(Integer.valueOf(Calendar.SUNDAY), new String[] { "display.date.week.full.sunday",
                "display.date.week.short.sunday", "display.date.week.shortest.sunday" });
        m.put(Integer.valueOf(Calendar.MONDAY), new String[] { "display.date.week.full.monday",
                "display.date.week.short.monday", "display.date.week.shortest.monday" });
        m.put(Integer.valueOf(Calendar.TUESDAY), new String[] { "display.date.week.full.tuesday",
                "display.date.week.short.tuesday", "display.date.week.shortest.tuesday" });
        m.put(Integer.valueOf(Calendar.WEDNESDAY), new String[] {
                "display.date.week.full.wednesday", "display.date.week.short.wednesday",
                "display.date.week.shortest.wednesday" });
        m.put(Integer.valueOf(Calendar.THURSDAY), new String[] { "display.date.week.full.thursday",
                "display.date.week.short.thursday", "display.date.week.shortest.thursday" });
        m.put(Integer.valueOf(Calendar.FRIDAY), new String[] { "display.date.week.full.friday",
                "display.date.week.short.friday", "display.date.week.shortest.friday" });
        m.put(Integer.valueOf(Calendar.SATURDAY), new String[] { "display.date.week.full.saturday",
                "display.date.week.short.saturday", "display.date.week.shortest.saturday" });

        return m;
    }

    private static Map<Integer, String[]> buildMonthNamesTable() {
        Map<Integer, String[]> m = new HashMap<Integer, String[]>();

        m.put(Integer.valueOf(Calendar.JANUARY), new String[] { "display.date.month.full.january",
                "display.date.month.short.january", "display.date.month.shortest.january" });
        m.put(Integer.valueOf(Calendar.FEBRUARY), new String[] {
                "display.date.month.full.february", "display.date.month.short.february",
                "display.date.month.shortest.february" });
        m.put(Integer.valueOf(Calendar.MARCH), new String[] { "display.date.month.full.march",
                "display.date.month.short.march", "display.date.month.shortest.march" });
        m.put(Integer.valueOf(Calendar.APRIL), new String[] { "display.date.month.full.april",
                "display.date.month.short.april", "display.date.month.shortest.april" });
        m.put(Integer.valueOf(Calendar.MAY), new String[] { "display.date.month.full.may",
                "display.date.month.short.may", "display.date.month.shortest.may" });
        m.put(Integer.valueOf(Calendar.JUNE), new String[] { "display.date.month.full.june",
                "display.date.month.short.june", "display.date.month.shortest.june" });
        m.put(Integer.valueOf(Calendar.JULY), new String[] { "display.date.month.full.july",
                "display.date.month.short.july", "display.date.month.shortest.july" });
        m.put(Integer.valueOf(Calendar.AUGUST), new String[] { "display.date.month.full.august",
                "display.date.month.short.august", "display.date.month.shortest.august" });
        m.put(Integer.valueOf(Calendar.SEPTEMBER), new String[] {
                "display.date.month.full.september", "display.date.month.short.september",
                "display.date.month.shortest.september" });
        m.put(Integer.valueOf(Calendar.OCTOBER), new String[] { "display.date.month.full.october",
                "display.date.month.short.october", "display.date.month.shortest.october" });
        m.put(Integer.valueOf(Calendar.NOVEMBER), new String[] {
                "display.date.month.full.november", "display.date.month.short.november",
                "display.date.month.shortest.november" });
        m.put(Integer.valueOf(Calendar.DECEMBER), new String[] {
                "display.date.month.full.december", "display.date.month.short.december",
                "display.date.month.shortest.december" });

        return m;
    }

    public static String getWeekdayNameKey(int d, int type) {
        if (weekdayNames.containsKey(Integer.valueOf(d))) {
            return ((String[]) weekdayNames.get(Integer.valueOf(d)))[type];
        } else {
            return "";
        }
    }

    public static String getMonthNameKey(int d, int type) {
        if (monthNames.containsKey(Integer.valueOf(d))) {
            return ((String[]) monthNames.get(Integer.valueOf(d)))[type];
        } else {
            return "";
        }
    }

    public static boolean checkDayStart(Calendar cal) {
        return cal.get(Calendar.HOUR_OF_DAY) == 0 && cal.get(Calendar.MINUTE) == 0;
    }

    public static String getTwoDigit(int value) {
        if (value >= 10) {
            return Integer.toString(value);
        } else {
            return "0" + Integer.toString(value);
        }
    }

    /**
     * 校验日期能否转为指定的格式，如果成功返回true 注意不能将 2010－13－01转换为2011－01－01等
     * 
     * @param date
     * @param dateFormat
     * @return
     */
    public static boolean validGivenFormat(String dateSource, String dateFormat) {
        boolean result = false;
        if (StringUtil.isEmpty(dateSource))
            return false;
        try {
            SimpleDateFormat format = new SimpleDateFormat(dateFormat);
            format.setLenient(false);
            format.parse(dateSource);
            result = true;
        } catch (ParseException e) {
            result = false;
        }
        return result;
    }

    /**
     * 校验日期能否转为指定的格式，如果成功返回true,且日期大于当前日期 注意不能将 2010－13－01转换为2011－01－01等
     * 
     * @param date
     * @param dateFormat
     * @return
     */
    public static boolean validDateAfterToday(String dateSource, String dateFormat) {
        boolean result = false;
        if (StringUtil.isEmpty(dateSource))
            return false;
        try {
            result = validGivenFormat(dateSource, dateFormat);
            if (result) {
                Date date = new SimpleDateFormat(dateFormat).parse(dateSource);
                result = date.after(new Date());
            }
        } catch (ParseException e) {
            result = false;
        }
        return result;
    }

    /**
     * 转换WS日期字符串至指定格式的日期字符串
     * 
     * @param wsDateStr
     * @param format
     * @return
     */
    public static String convertWsDate(String wsDateStr, String format) {
        if (StringUtils.isNotBlank(wsDateStr)) {
            try {
                return formateDate(parseWsDate(wsDateStr), format);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return "";
    }

    /**
     * 获取两个指定日期间的所有日期
     * @param startDate
     * @param endDate
     * @return
     * @throws ParseException
     */
    public static List<Date> getBetweenDate(Date startDate, Date endDate) throws ParseException {
        List<Date> list = new ArrayList<Date>();
        
        if(startDate != null && endDate != null){
            GregorianCalendar gc1 = new GregorianCalendar();
            GregorianCalendar gc2 = new GregorianCalendar();
            gc1.setTime(startDate);
            gc2.setTime(endDate);
            
            GregorianCalendar gc3;
            do {
                gc3 = (GregorianCalendar) gc1.clone();
                if(DateUtils.isSameDay(gc3.getTime(), startDate)){
                    gc3.set(Calendar.HOUR_OF_DAY, gc1.get(Calendar.HOUR_OF_DAY));
                }else if(DateUtils.isSameDay(gc2, gc3)){
                    gc3.set(Calendar.HOUR_OF_DAY, gc2.get(Calendar.HOUR_OF_DAY));
                }else{
                    gc3.set(Calendar.HOUR_OF_DAY, 0);
                }
                list.add(gc3.getTime());
                gc1.add(Calendar.DAY_OF_MONTH, 1);
            } while (!gc1.after(gc2));
        }else{
            if(startDate != null){
                list.add(startDate);
            }
            if(endDate != null){
                list.add(endDate);
            };
        }
        return list;
    }
    
    /**
     * 判断是否为工作日<br/>
     * 周一到周五为工作日
     * @author wb_suoyao.shen 2012.04.15
     * @param date
     * @return
     */
    public static boolean isWorkday(Date date) {
        int iWeek = getDayOfWeek(date);
        if (iWeek >= 1 && iWeek <= 5) {
            return true;
        }
        return false;
    }
    
    /**
     * 判断是否为工作日<br/>
     * 周一到周五为工作日
     * @param date
     * @return
     */
    public static boolean isWorkday(String date) {
        DateFormat df = new SimpleDateFormat(DATE_FORMAT);
        try {
            return isWorkday(df.parse(date));
        } catch(ParseException e) {
            return false;
        }
    }
    
    /**
     * 返回当前时日是星期几
     * @author wb_suoyao.shen 2012.05.15
     * @param date
     * @return
     */
    public static int getDayOfWeek(Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        return cal.get(Calendar.DAY_OF_WEEK) -1;
    }
}
